﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using PAT.Entities;
using PAT.Data;
using PAT.Data.Bases;

#endregion

namespace PAT.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("PAT.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.9.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				// use default ConnectionStrings if _section has already been discovered
				if ( _config == null && _section != null )
				{
					return WebConfigurationManager.ConnectionStrings;
				}
				
				return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region PatRolProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatRol"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatRolProviderBase PatRolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatRolProvider;
			}
		}
		
		#endregion
		
		#region PatTipoUbicacionGeograficaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoUbicacionGeografica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoUbicacionGeograficaProviderBase PatTipoUbicacionGeograficaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoUbicacionGeograficaProvider;
			}
		}
		
		#endregion
		
		#region PatGrupoCatalogoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatGrupoCatalogo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatGrupoCatalogoProviderBase PatGrupoCatalogoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatGrupoCatalogoProvider;
			}
		}
		
		#endregion
		
		#region PatAccesorioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatAccesorio"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatAccesorioProviderBase PatAccesorioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatAccesorioProvider;
			}
		}
		
		#endregion
		
		#region PatRolMenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatRolMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatRolMenuProviderBase PatRolMenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatRolMenuProvider;
			}
		}
		
		#endregion
		
		#region PatTemparioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTempario"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTemparioProviderBase PatTemparioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTemparioProvider;
			}
		}
		
		#endregion
		
		#region PatUbicacionGeograficaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatUbicacionGeografica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatUbicacionGeograficaProviderBase PatUbicacionGeograficaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatUbicacionGeograficaProvider;
			}
		}
		
		#endregion
		
		#region PatTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTallerProviderBase PatTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTallerProvider;
			}
		}
		
		#endregion
		
		#region PatTiempoTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTiempoTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTiempoTallerProviderBase PatTiempoTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTiempoTallerProvider;
			}
		}
		
		#endregion
		
		#region PatRegimenTributarioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatRegimenTributario"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatRegimenTributarioProviderBase PatRegimenTributarioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatRegimenTributarioProvider;
			}
		}
		
		#endregion
		
		#region PatNaturalezaDocumentoIdentificacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatNaturalezaDocumentoIdentificacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatNaturalezaDocumentoIdentificacionProviderBase PatNaturalezaDocumentoIdentificacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatNaturalezaDocumentoIdentificacionProvider;
			}
		}
		
		#endregion
		
		#region PatListaPreciosTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatListaPreciosTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatListaPreciosTallerProviderBase PatListaPreciosTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatListaPreciosTallerProvider;
			}
		}
		
		#endregion
		
		#region PatNivelCombustibleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatNivelCombustible"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatNivelCombustibleProviderBase PatNivelCombustibleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatNivelCombustibleProvider;
			}
		}
		
		#endregion
		
		#region PatOperacionTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOperacionTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOperacionTallerProviderBase PatOperacionTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOperacionTallerProvider;
			}
		}
		
		#endregion
		
		#region PatKitProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatKit"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatKitProviderBase PatKitProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatKitProvider;
			}
		}
		
		#endregion
		
		#region PatTipoCombustibleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoCombustible"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoCombustibleProviderBase PatTipoCombustibleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoCombustibleProvider;
			}
		}
		
		#endregion
		
		#region PatValorOrdenProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatValorOrden"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatValorOrdenProviderBase PatValorOrdenProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatValorOrdenProvider;
			}
		}
		
		#endregion
		
		#region PatTrabajoOrdenProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTrabajoOrden"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTrabajoOrdenProviderBase PatTrabajoOrdenProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTrabajoOrdenProvider;
			}
		}
		
		#endregion
		
		#region PatTipoDocumentoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoDocumento"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoDocumentoProviderBase PatTipoDocumentoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoDocumentoProvider;
			}
		}
		
		#endregion
		
		#region PatUsuarioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatUsuario"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatUsuarioProviderBase PatUsuarioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatUsuarioProvider;
			}
		}
		
		#endregion
		
		#region PatUsuarioRolProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatUsuarioRol"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatUsuarioRolProviderBase PatUsuarioRolProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatUsuarioRolProvider;
			}
		}
		
		#endregion
		
		#region PatTipoServicioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoServicio"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoServicioProviderBase PatTipoServicioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoServicioProvider;
			}
		}
		
		#endregion
		
		#region PatTipoPropietarioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoPropietario"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoPropietarioProviderBase PatTipoPropietarioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoPropietarioProvider;
			}
		}
		
		#endregion
		
		#region PatTransferenciaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTransferencia"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTransferenciaProviderBase PatTransferenciaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTransferenciaProvider;
			}
		}
		
		#endregion
		
		#region PatTipoIdentificacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoIdentificacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoIdentificacionProviderBase PatTipoIdentificacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoIdentificacionProvider;
			}
		}
		
		#endregion
		
		#region PatTipoLiquidacionTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoLiquidacionTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoLiquidacionTallerProviderBase PatTipoLiquidacionTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoLiquidacionTallerProvider;
			}
		}
		
		#endregion
		
		#region PatTransferenciaDetalleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTransferenciaDetalle"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTransferenciaDetalleProviderBase PatTransferenciaDetalleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTransferenciaDetalleProvider;
			}
		}
		
		#endregion
		
		#region PatTipoEmpleadoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoEmpleado"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoEmpleadoProviderBase PatTipoEmpleadoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoEmpleadoProvider;
			}
		}
		
		#endregion
		
		#region PatTipoOperacionTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatTipoOperacionTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatTipoOperacionTallerProviderBase PatTipoOperacionTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatTipoOperacionTallerProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoGarantiaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoGarantia"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoGarantiaProviderBase PatOrdenTrabajoGarantiaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoGarantiaProvider;
			}
		}
		
		#endregion
		
		#region PatMenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatMenuProviderBase PatMenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatMenuProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoProviderBase PatOrdenTrabajoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoOperacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoOperacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoOperacionProviderBase PatOrdenTrabajoOperacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoOperacionProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoAccesorioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoAccesorio"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoAccesorioProviderBase PatOrdenTrabajoAccesorioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoAccesorioProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoSegurosProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoSeguros"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoSegurosProviderBase PatOrdenTrabajoSegurosProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoSegurosProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoPeritajeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoPeritaje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoPeritajeProviderBase PatOrdenTrabajoPeritajeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoPeritajeProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoKitProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoKit"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoKitProviderBase PatOrdenTrabajoKitProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoKitProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoOperacionObservacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoOperacionObservacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoOperacionObservacionProviderBase PatOrdenTrabajoOperacionObservacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoOperacionObservacionProvider;
			}
		}
		
		#endregion
		
		#region PatOrdenTrabajoTransferenciaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatOrdenTrabajoTransferencia"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatOrdenTrabajoTransferenciaProviderBase PatOrdenTrabajoTransferenciaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatOrdenTrabajoTransferenciaProvider;
			}
		}
		
		#endregion
		
		#region PatEmpleadoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEmpleado"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEmpleadoProviderBase PatEmpleadoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEmpleadoProvider;
			}
		}
		
		#endregion
		
		#region PatMarcaVehiculoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatMarcaVehiculo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatMarcaVehiculoProviderBase PatMarcaVehiculoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatMarcaVehiculoProvider;
			}
		}
		
		#endregion
		
		#region PatEmpresaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEmpresa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEmpresaProviderBase PatEmpresaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEmpresaProvider;
			}
		}
		
		#endregion
		
		#region PatDocumentoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatDocumento"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatDocumentoProviderBase PatDocumentoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatDocumentoProvider;
			}
		}
		
		#endregion
		
		#region PatEmpresaTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEmpresaTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEmpresaTallerProviderBase PatEmpresaTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEmpresaTallerProvider;
			}
		}
		
		#endregion
		
		#region PatEstadoLiquidacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEstadoLiquidacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEstadoLiquidacionProviderBase PatEstadoLiquidacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEstadoLiquidacionProvider;
			}
		}
		
		#endregion
		
		#region PatEspecialidadMecanicoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEspecialidadMecanico"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEspecialidadMecanicoProviderBase PatEspecialidadMecanicoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEspecialidadMecanicoProvider;
			}
		}
		
		#endregion
		
		#region PatConfiguracionTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatConfiguracionTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatConfiguracionTallerProviderBase PatConfiguracionTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatConfiguracionTallerProvider;
			}
		}
		
		#endregion
		
		#region PatEstadoCitaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEstadoCita"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEstadoCitaProviderBase PatEstadoCitaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEstadoCitaProvider;
			}
		}
		
		#endregion
		
		#region PatCargoOrdenProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCargoOrden"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatCargoOrdenProviderBase PatCargoOrdenProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatCargoOrdenProvider;
			}
		}
		
		#endregion
		
		#region PatColorProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatColor"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatColorProviderBase PatColorProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatColorProvider;
			}
		}
		
		#endregion
		
		#region PatCatalogoVehiculoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCatalogoVehiculo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatCatalogoVehiculoProviderBase PatCatalogoVehiculoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatCatalogoVehiculoProvider;
			}
		}
		
		#endregion
		
		#region PatCapacidadTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCapacidadTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatCapacidadTallerProviderBase PatCapacidadTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatCapacidadTallerProvider;
			}
		}
		
		#endregion
		
		#region PatCausalGarantiaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCausalGarantia"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatCausalGarantiaProviderBase PatCausalGarantiaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatCausalGarantiaProvider;
			}
		}
		
		#endregion
		
		#region PatClienteProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCliente"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatClienteProviderBase PatClienteProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatClienteProvider;
			}
		}
		
		#endregion
		
		#region PatClaseVehiculoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatClaseVehiculo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatClaseVehiculoProviderBase PatClaseVehiculoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatClaseVehiculoProvider;
			}
		}
		
		#endregion
		
		#region PatCitaTallerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatCitaTaller"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatCitaTallerProviderBase PatCitaTallerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatCitaTallerProvider;
			}
		}
		
		#endregion
		
		#region PatEstadoOperacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEstadoOperacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEstadoOperacionProviderBase PatEstadoOperacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEstadoOperacionProvider;
			}
		}
		
		#endregion
		
		#region PatItemListaPreciosProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemListaPrecios"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemListaPreciosProviderBase PatItemListaPreciosProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemListaPreciosProvider;
			}
		}
		
		#endregion
		
		#region PatEstadoOrdenProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEstadoOrden"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEstadoOrdenProviderBase PatEstadoOrdenProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEstadoOrdenProvider;
			}
		}
		
		#endregion
		
		#region PatItemOperacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemOperacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemOperacionProviderBase PatItemOperacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemOperacionProvider;
			}
		}
		
		#endregion
		
		#region PatItemInventarioListaPreciosProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemInventarioListaPrecios"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemInventarioListaPreciosProviderBase PatItemInventarioListaPreciosProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemInventarioListaPreciosProvider;
			}
		}
		
		#endregion
		
		#region PatItemPeritajeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemPeritaje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemPeritajeProviderBase PatItemPeritajeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemPeritajeProvider;
			}
		}
		
		#endregion
		
		#region PatMantenimientoProgramadoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatMantenimientoProgramado"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatMantenimientoProgramadoProviderBase PatMantenimientoProgramadoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatMantenimientoProgramadoProvider;
			}
		}
		
		#endregion
		
		#region PatKitItemProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatKitItem"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatKitItemProviderBase PatKitItemProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatKitItemProvider;
			}
		}
		
		#endregion
		
		#region PatItemInventarioProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemInventario"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemInventarioProviderBase PatItemInventarioProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemInventarioProvider;
			}
		}
		
		#endregion
		
		#region PatKitOperacionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatKitOperacion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatKitOperacionProviderBase PatKitOperacionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatKitOperacionProvider;
			}
		}
		
		#endregion
		
		#region PatHistoricEntityProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatHistoricEntity"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatHistoricEntityProviderBase PatHistoricEntityProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatHistoricEntityProvider;
			}
		}
		
		#endregion
		
		#region PatItemGrupoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemGrupo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemGrupoProviderBase PatItemGrupoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemGrupoProvider;
			}
		}
		
		#endregion
		
		#region PatEstadoPeritajeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatEstadoPeritaje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatEstadoPeritajeProviderBase PatEstadoPeritajeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatEstadoPeritajeProvider;
			}
		}
		
		#endregion
		
		#region PatHistoricAttributeByEntityProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatHistoricAttributeByEntity"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatHistoricAttributeByEntityProviderBase PatHistoricAttributeByEntityProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatHistoricAttributeByEntityProvider;
			}
		}
		
		#endregion
		
		#region PatGamaVehiculoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatGamaVehiculo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatGamaVehiculoProviderBase PatGamaVehiculoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatGamaVehiculoProvider;
			}
		}
		
		#endregion
		
		#region PatGrupoPeritajeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatGrupoPeritaje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatGrupoPeritajeProviderBase PatGrupoPeritajeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatGrupoPeritajeProvider;
			}
		}
		
		#endregion
		
		#region PatHistoricProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatHistoric"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatHistoricProviderBase PatHistoricProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatHistoricProvider;
			}
		}
		
		#endregion
		
		#region PatItemCatalogoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatItemCatalogo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatItemCatalogoProviderBase PatItemCatalogoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatItemCatalogoProvider;
			}
		}
		
		#endregion
		
		#region PatVehiculoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PatVehiculo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PatVehiculoProviderBase PatVehiculoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PatVehiculoProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region PatRolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatRol"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRolFilters : PatRolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRolFilters class.
		/// </summary>
		public PatRolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRolFilters
	
	#region PatRolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatRolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatRol"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRolQuery : PatRolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRolQuery class.
		/// </summary>
		public PatRolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRolQuery
		
	#region PatTipoUbicacionGeograficaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoUbicacionGeografica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoUbicacionGeograficaFilters : PatTipoUbicacionGeograficaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaFilters class.
		/// </summary>
		public PatTipoUbicacionGeograficaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoUbicacionGeograficaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoUbicacionGeograficaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoUbicacionGeograficaFilters
	
	#region PatTipoUbicacionGeograficaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoUbicacionGeograficaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoUbicacionGeografica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoUbicacionGeograficaQuery : PatTipoUbicacionGeograficaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaQuery class.
		/// </summary>
		public PatTipoUbicacionGeograficaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoUbicacionGeograficaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoUbicacionGeograficaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoUbicacionGeograficaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoUbicacionGeograficaQuery
		
	#region PatGrupoCatalogoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatGrupoCatalogo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGrupoCatalogoFilters : PatGrupoCatalogoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoFilters class.
		/// </summary>
		public PatGrupoCatalogoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGrupoCatalogoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGrupoCatalogoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGrupoCatalogoFilters
	
	#region PatGrupoCatalogoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatGrupoCatalogoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatGrupoCatalogo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGrupoCatalogoQuery : PatGrupoCatalogoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoQuery class.
		/// </summary>
		public PatGrupoCatalogoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGrupoCatalogoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoCatalogoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGrupoCatalogoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGrupoCatalogoQuery
		
	#region PatAccesorioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatAccesorio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatAccesorioFilters : PatAccesorioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatAccesorioFilters class.
		/// </summary>
		public PatAccesorioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatAccesorioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatAccesorioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatAccesorioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatAccesorioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatAccesorioFilters
	
	#region PatAccesorioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatAccesorioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatAccesorio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatAccesorioQuery : PatAccesorioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatAccesorioQuery class.
		/// </summary>
		public PatAccesorioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatAccesorioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatAccesorioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatAccesorioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatAccesorioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatAccesorioQuery
		
	#region PatRolMenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatRolMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRolMenuFilters : PatRolMenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRolMenuFilters class.
		/// </summary>
		public PatRolMenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRolMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRolMenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRolMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRolMenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRolMenuFilters
	
	#region PatRolMenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatRolMenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatRolMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRolMenuQuery : PatRolMenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRolMenuQuery class.
		/// </summary>
		public PatRolMenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRolMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRolMenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRolMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRolMenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRolMenuQuery
		
	#region PatTemparioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTempario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTemparioFilters : PatTemparioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTemparioFilters class.
		/// </summary>
		public PatTemparioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTemparioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTemparioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTemparioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTemparioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTemparioFilters
	
	#region PatTemparioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTemparioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTempario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTemparioQuery : PatTemparioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTemparioQuery class.
		/// </summary>
		public PatTemparioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTemparioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTemparioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTemparioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTemparioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTemparioQuery
		
	#region PatUbicacionGeograficaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatUbicacionGeografica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUbicacionGeograficaFilters : PatUbicacionGeograficaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaFilters class.
		/// </summary>
		public PatUbicacionGeograficaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUbicacionGeograficaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUbicacionGeograficaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUbicacionGeograficaFilters
	
	#region PatUbicacionGeograficaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatUbicacionGeograficaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatUbicacionGeografica"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUbicacionGeograficaQuery : PatUbicacionGeograficaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaQuery class.
		/// </summary>
		public PatUbicacionGeograficaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUbicacionGeograficaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUbicacionGeograficaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUbicacionGeograficaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUbicacionGeograficaQuery
		
	#region PatTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTallerFilters : PatTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTallerFilters class.
		/// </summary>
		public PatTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTallerFilters
	
	#region PatTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTallerQuery : PatTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTallerQuery class.
		/// </summary>
		public PatTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTallerQuery
		
	#region PatTiempoTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTiempoTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTiempoTallerFilters : PatTiempoTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerFilters class.
		/// </summary>
		public PatTiempoTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTiempoTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTiempoTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTiempoTallerFilters
	
	#region PatTiempoTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTiempoTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTiempoTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTiempoTallerQuery : PatTiempoTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerQuery class.
		/// </summary>
		public PatTiempoTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTiempoTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTiempoTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTiempoTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTiempoTallerQuery
		
	#region PatRegimenTributarioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatRegimenTributario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRegimenTributarioFilters : PatRegimenTributarioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioFilters class.
		/// </summary>
		public PatRegimenTributarioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRegimenTributarioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRegimenTributarioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRegimenTributarioFilters
	
	#region PatRegimenTributarioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatRegimenTributarioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatRegimenTributario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatRegimenTributarioQuery : PatRegimenTributarioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioQuery class.
		/// </summary>
		public PatRegimenTributarioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatRegimenTributarioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatRegimenTributarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatRegimenTributarioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatRegimenTributarioQuery
		
	#region PatNaturalezaDocumentoIdentificacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatNaturalezaDocumentoIdentificacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatNaturalezaDocumentoIdentificacionFilters : PatNaturalezaDocumentoIdentificacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionFilters class.
		/// </summary>
		public PatNaturalezaDocumentoIdentificacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatNaturalezaDocumentoIdentificacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatNaturalezaDocumentoIdentificacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatNaturalezaDocumentoIdentificacionFilters
	
	#region PatNaturalezaDocumentoIdentificacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatNaturalezaDocumentoIdentificacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatNaturalezaDocumentoIdentificacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatNaturalezaDocumentoIdentificacionQuery : PatNaturalezaDocumentoIdentificacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionQuery class.
		/// </summary>
		public PatNaturalezaDocumentoIdentificacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatNaturalezaDocumentoIdentificacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatNaturalezaDocumentoIdentificacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatNaturalezaDocumentoIdentificacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatNaturalezaDocumentoIdentificacionQuery
		
	#region PatListaPreciosTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatListaPreciosTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatListaPreciosTallerFilters : PatListaPreciosTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerFilters class.
		/// </summary>
		public PatListaPreciosTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatListaPreciosTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatListaPreciosTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatListaPreciosTallerFilters
	
	#region PatListaPreciosTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatListaPreciosTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatListaPreciosTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatListaPreciosTallerQuery : PatListaPreciosTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerQuery class.
		/// </summary>
		public PatListaPreciosTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatListaPreciosTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatListaPreciosTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatListaPreciosTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatListaPreciosTallerQuery
		
	#region PatNivelCombustibleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatNivelCombustible"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatNivelCombustibleFilters : PatNivelCombustibleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleFilters class.
		/// </summary>
		public PatNivelCombustibleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatNivelCombustibleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatNivelCombustibleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatNivelCombustibleFilters
	
	#region PatNivelCombustibleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatNivelCombustibleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatNivelCombustible"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatNivelCombustibleQuery : PatNivelCombustibleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleQuery class.
		/// </summary>
		public PatNivelCombustibleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatNivelCombustibleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatNivelCombustibleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatNivelCombustibleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatNivelCombustibleQuery
		
	#region PatOperacionTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOperacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOperacionTallerFilters : PatOperacionTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerFilters class.
		/// </summary>
		public PatOperacionTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOperacionTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOperacionTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOperacionTallerFilters
	
	#region PatOperacionTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOperacionTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOperacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOperacionTallerQuery : PatOperacionTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerQuery class.
		/// </summary>
		public PatOperacionTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOperacionTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOperacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOperacionTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOperacionTallerQuery
		
	#region PatKitFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatKit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitFilters : PatKitFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitFilters class.
		/// </summary>
		public PatKitFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitFilters
	
	#region PatKitQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatKitParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatKit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitQuery : PatKitParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitQuery class.
		/// </summary>
		public PatKitQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitQuery
		
	#region PatTipoCombustibleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoCombustible"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoCombustibleFilters : PatTipoCombustibleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleFilters class.
		/// </summary>
		public PatTipoCombustibleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoCombustibleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoCombustibleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoCombustibleFilters
	
	#region PatTipoCombustibleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoCombustibleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoCombustible"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoCombustibleQuery : PatTipoCombustibleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleQuery class.
		/// </summary>
		public PatTipoCombustibleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoCombustibleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoCombustibleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoCombustibleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoCombustibleQuery
		
	#region PatValorOrdenFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatValorOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatValorOrdenFilters : PatValorOrdenFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenFilters class.
		/// </summary>
		public PatValorOrdenFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatValorOrdenFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatValorOrdenFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatValorOrdenFilters
	
	#region PatValorOrdenQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatValorOrdenParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatValorOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatValorOrdenQuery : PatValorOrdenParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenQuery class.
		/// </summary>
		public PatValorOrdenQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatValorOrdenQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatValorOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatValorOrdenQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatValorOrdenQuery
		
	#region PatTrabajoOrdenFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTrabajoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTrabajoOrdenFilters : PatTrabajoOrdenFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenFilters class.
		/// </summary>
		public PatTrabajoOrdenFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTrabajoOrdenFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTrabajoOrdenFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTrabajoOrdenFilters
	
	#region PatTrabajoOrdenQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTrabajoOrdenParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTrabajoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTrabajoOrdenQuery : PatTrabajoOrdenParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenQuery class.
		/// </summary>
		public PatTrabajoOrdenQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTrabajoOrdenQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTrabajoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTrabajoOrdenQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTrabajoOrdenQuery
		
	#region PatTipoDocumentoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoDocumento"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoDocumentoFilters : PatTipoDocumentoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoFilters class.
		/// </summary>
		public PatTipoDocumentoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoDocumentoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoDocumentoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoDocumentoFilters
	
	#region PatTipoDocumentoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoDocumentoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoDocumento"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoDocumentoQuery : PatTipoDocumentoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoQuery class.
		/// </summary>
		public PatTipoDocumentoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoDocumentoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoDocumentoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoDocumentoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoDocumentoQuery
		
	#region PatUsuarioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatUsuario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUsuarioFilters : PatUsuarioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUsuarioFilters class.
		/// </summary>
		public PatUsuarioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUsuarioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUsuarioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUsuarioFilters
	
	#region PatUsuarioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatUsuarioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatUsuario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUsuarioQuery : PatUsuarioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUsuarioQuery class.
		/// </summary>
		public PatUsuarioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUsuarioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUsuarioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUsuarioQuery
		
	#region PatUsuarioRolFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatUsuarioRol"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUsuarioRolFilters : PatUsuarioRolFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolFilters class.
		/// </summary>
		public PatUsuarioRolFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUsuarioRolFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUsuarioRolFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUsuarioRolFilters
	
	#region PatUsuarioRolQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatUsuarioRolParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatUsuarioRol"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatUsuarioRolQuery : PatUsuarioRolParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolQuery class.
		/// </summary>
		public PatUsuarioRolQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatUsuarioRolQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatUsuarioRolQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatUsuarioRolQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatUsuarioRolQuery
		
	#region PatTipoServicioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoServicio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoServicioFilters : PatTipoServicioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioFilters class.
		/// </summary>
		public PatTipoServicioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoServicioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoServicioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoServicioFilters
	
	#region PatTipoServicioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoServicioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoServicio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoServicioQuery : PatTipoServicioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioQuery class.
		/// </summary>
		public PatTipoServicioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoServicioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoServicioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoServicioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoServicioQuery
		
	#region PatTipoPropietarioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoPropietario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoPropietarioFilters : PatTipoPropietarioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioFilters class.
		/// </summary>
		public PatTipoPropietarioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoPropietarioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoPropietarioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoPropietarioFilters
	
	#region PatTipoPropietarioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoPropietarioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoPropietario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoPropietarioQuery : PatTipoPropietarioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioQuery class.
		/// </summary>
		public PatTipoPropietarioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoPropietarioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoPropietarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoPropietarioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoPropietarioQuery
		
	#region PatTransferenciaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTransferencia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTransferenciaFilters : PatTransferenciaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaFilters class.
		/// </summary>
		public PatTransferenciaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTransferenciaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTransferenciaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTransferenciaFilters
	
	#region PatTransferenciaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTransferenciaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTransferencia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTransferenciaQuery : PatTransferenciaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaQuery class.
		/// </summary>
		public PatTransferenciaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTransferenciaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTransferenciaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTransferenciaQuery
		
	#region PatTipoIdentificacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoIdentificacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoIdentificacionFilters : PatTipoIdentificacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionFilters class.
		/// </summary>
		public PatTipoIdentificacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoIdentificacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoIdentificacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoIdentificacionFilters
	
	#region PatTipoIdentificacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoIdentificacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoIdentificacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoIdentificacionQuery : PatTipoIdentificacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionQuery class.
		/// </summary>
		public PatTipoIdentificacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoIdentificacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoIdentificacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoIdentificacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoIdentificacionQuery
		
	#region PatTipoLiquidacionTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoLiquidacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoLiquidacionTallerFilters : PatTipoLiquidacionTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerFilters class.
		/// </summary>
		public PatTipoLiquidacionTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoLiquidacionTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoLiquidacionTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoLiquidacionTallerFilters
	
	#region PatTipoLiquidacionTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoLiquidacionTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoLiquidacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoLiquidacionTallerQuery : PatTipoLiquidacionTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerQuery class.
		/// </summary>
		public PatTipoLiquidacionTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoLiquidacionTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoLiquidacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoLiquidacionTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoLiquidacionTallerQuery
		
	#region PatTransferenciaDetalleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTransferenciaDetalle"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTransferenciaDetalleFilters : PatTransferenciaDetalleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleFilters class.
		/// </summary>
		public PatTransferenciaDetalleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTransferenciaDetalleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTransferenciaDetalleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTransferenciaDetalleFilters
	
	#region PatTransferenciaDetalleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTransferenciaDetalleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTransferenciaDetalle"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTransferenciaDetalleQuery : PatTransferenciaDetalleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleQuery class.
		/// </summary>
		public PatTransferenciaDetalleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTransferenciaDetalleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTransferenciaDetalleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTransferenciaDetalleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTransferenciaDetalleQuery
		
	#region PatTipoEmpleadoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoEmpleado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoEmpleadoFilters : PatTipoEmpleadoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoFilters class.
		/// </summary>
		public PatTipoEmpleadoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoEmpleadoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoEmpleadoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoEmpleadoFilters
	
	#region PatTipoEmpleadoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoEmpleadoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoEmpleado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoEmpleadoQuery : PatTipoEmpleadoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoQuery class.
		/// </summary>
		public PatTipoEmpleadoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoEmpleadoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoEmpleadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoEmpleadoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoEmpleadoQuery
		
	#region PatTipoOperacionTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatTipoOperacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoOperacionTallerFilters : PatTipoOperacionTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerFilters class.
		/// </summary>
		public PatTipoOperacionTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoOperacionTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoOperacionTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoOperacionTallerFilters
	
	#region PatTipoOperacionTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatTipoOperacionTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatTipoOperacionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatTipoOperacionTallerQuery : PatTipoOperacionTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerQuery class.
		/// </summary>
		public PatTipoOperacionTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatTipoOperacionTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatTipoOperacionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatTipoOperacionTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatTipoOperacionTallerQuery
		
	#region PatOrdenTrabajoGarantiaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoGarantia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoGarantiaFilters : PatOrdenTrabajoGarantiaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaFilters class.
		/// </summary>
		public PatOrdenTrabajoGarantiaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoGarantiaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoGarantiaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoGarantiaFilters
	
	#region PatOrdenTrabajoGarantiaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoGarantiaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoGarantia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoGarantiaQuery : PatOrdenTrabajoGarantiaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaQuery class.
		/// </summary>
		public PatOrdenTrabajoGarantiaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoGarantiaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoGarantiaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoGarantiaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoGarantiaQuery
		
	#region PatMenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMenuFilters : PatMenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMenuFilters class.
		/// </summary>
		public PatMenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMenuFilters
	
	#region PatMenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatMenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMenuQuery : PatMenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMenuQuery class.
		/// </summary>
		public PatMenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMenuQuery
		
	#region PatOrdenTrabajoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoFilters : PatOrdenTrabajoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoFilters class.
		/// </summary>
		public PatOrdenTrabajoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoFilters
	
	#region PatOrdenTrabajoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoQuery : PatOrdenTrabajoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoQuery class.
		/// </summary>
		public PatOrdenTrabajoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoQuery
		
	#region PatOrdenTrabajoOperacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoOperacionFilters : PatOrdenTrabajoOperacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionFilters class.
		/// </summary>
		public PatOrdenTrabajoOperacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoOperacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoOperacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoOperacionFilters
	
	#region PatOrdenTrabajoOperacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoOperacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoOperacionQuery : PatOrdenTrabajoOperacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionQuery class.
		/// </summary>
		public PatOrdenTrabajoOperacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoOperacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoOperacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoOperacionQuery
		
	#region PatOrdenTrabajoAccesorioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoAccesorio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoAccesorioFilters : PatOrdenTrabajoAccesorioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioFilters class.
		/// </summary>
		public PatOrdenTrabajoAccesorioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoAccesorioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoAccesorioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoAccesorioFilters
	
	#region PatOrdenTrabajoAccesorioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoAccesorioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoAccesorio"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoAccesorioQuery : PatOrdenTrabajoAccesorioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioQuery class.
		/// </summary>
		public PatOrdenTrabajoAccesorioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoAccesorioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoAccesorioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoAccesorioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoAccesorioQuery
		
	#region PatOrdenTrabajoSegurosFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoSeguros"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoSegurosFilters : PatOrdenTrabajoSegurosFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosFilters class.
		/// </summary>
		public PatOrdenTrabajoSegurosFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoSegurosFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoSegurosFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoSegurosFilters
	
	#region PatOrdenTrabajoSegurosQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoSegurosParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoSeguros"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoSegurosQuery : PatOrdenTrabajoSegurosParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosQuery class.
		/// </summary>
		public PatOrdenTrabajoSegurosQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoSegurosQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoSegurosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoSegurosQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoSegurosQuery
		
	#region PatOrdenTrabajoPeritajeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoPeritajeFilters : PatOrdenTrabajoPeritajeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeFilters class.
		/// </summary>
		public PatOrdenTrabajoPeritajeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoPeritajeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoPeritajeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoPeritajeFilters
	
	#region PatOrdenTrabajoPeritajeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoPeritajeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoPeritajeQuery : PatOrdenTrabajoPeritajeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeQuery class.
		/// </summary>
		public PatOrdenTrabajoPeritajeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoPeritajeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoPeritajeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoPeritajeQuery
		
	#region PatOrdenTrabajoKitFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoKit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoKitFilters : PatOrdenTrabajoKitFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitFilters class.
		/// </summary>
		public PatOrdenTrabajoKitFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoKitFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoKitFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoKitFilters
	
	#region PatOrdenTrabajoKitQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoKitParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoKit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoKitQuery : PatOrdenTrabajoKitParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitQuery class.
		/// </summary>
		public PatOrdenTrabajoKitQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoKitQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoKitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoKitQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoKitQuery
		
	#region PatOrdenTrabajoOperacionObservacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoOperacionObservacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoOperacionObservacionFilters : PatOrdenTrabajoOperacionObservacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionFilters class.
		/// </summary>
		public PatOrdenTrabajoOperacionObservacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoOperacionObservacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoOperacionObservacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoOperacionObservacionFilters
	
	#region PatOrdenTrabajoOperacionObservacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoOperacionObservacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoOperacionObservacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoOperacionObservacionQuery : PatOrdenTrabajoOperacionObservacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionQuery class.
		/// </summary>
		public PatOrdenTrabajoOperacionObservacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoOperacionObservacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoOperacionObservacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoOperacionObservacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoOperacionObservacionQuery
		
	#region PatOrdenTrabajoTransferenciaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoTransferencia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoTransferenciaFilters : PatOrdenTrabajoTransferenciaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaFilters class.
		/// </summary>
		public PatOrdenTrabajoTransferenciaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoTransferenciaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoTransferenciaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoTransferenciaFilters
	
	#region PatOrdenTrabajoTransferenciaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatOrdenTrabajoTransferenciaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatOrdenTrabajoTransferencia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatOrdenTrabajoTransferenciaQuery : PatOrdenTrabajoTransferenciaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaQuery class.
		/// </summary>
		public PatOrdenTrabajoTransferenciaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatOrdenTrabajoTransferenciaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatOrdenTrabajoTransferenciaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatOrdenTrabajoTransferenciaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatOrdenTrabajoTransferenciaQuery
		
	#region PatEmpleadoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEmpleado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpleadoFilters : PatEmpleadoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoFilters class.
		/// </summary>
		public PatEmpleadoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpleadoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpleadoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpleadoFilters
	
	#region PatEmpleadoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEmpleadoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEmpleado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpleadoQuery : PatEmpleadoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoQuery class.
		/// </summary>
		public PatEmpleadoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpleadoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpleadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpleadoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpleadoQuery
		
	#region PatMarcaVehiculoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatMarcaVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMarcaVehiculoFilters : PatMarcaVehiculoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoFilters class.
		/// </summary>
		public PatMarcaVehiculoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMarcaVehiculoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMarcaVehiculoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMarcaVehiculoFilters
	
	#region PatMarcaVehiculoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatMarcaVehiculoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatMarcaVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMarcaVehiculoQuery : PatMarcaVehiculoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoQuery class.
		/// </summary>
		public PatMarcaVehiculoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMarcaVehiculoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMarcaVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMarcaVehiculoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMarcaVehiculoQuery
		
	#region PatEmpresaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEmpresa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpresaFilters : PatEmpresaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpresaFilters class.
		/// </summary>
		public PatEmpresaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpresaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpresaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpresaFilters
	
	#region PatEmpresaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEmpresaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEmpresa"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpresaQuery : PatEmpresaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpresaQuery class.
		/// </summary>
		public PatEmpresaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpresaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpresaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpresaQuery
		
	#region PatDocumentoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatDocumento"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatDocumentoFilters : PatDocumentoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatDocumentoFilters class.
		/// </summary>
		public PatDocumentoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatDocumentoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatDocumentoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatDocumentoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatDocumentoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatDocumentoFilters
	
	#region PatDocumentoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatDocumentoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatDocumento"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatDocumentoQuery : PatDocumentoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatDocumentoQuery class.
		/// </summary>
		public PatDocumentoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatDocumentoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatDocumentoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatDocumentoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatDocumentoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatDocumentoQuery
		
	#region PatEmpresaTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEmpresaTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpresaTallerFilters : PatEmpresaTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerFilters class.
		/// </summary>
		public PatEmpresaTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpresaTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpresaTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpresaTallerFilters
	
	#region PatEmpresaTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEmpresaTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEmpresaTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEmpresaTallerQuery : PatEmpresaTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerQuery class.
		/// </summary>
		public PatEmpresaTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEmpresaTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEmpresaTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEmpresaTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEmpresaTallerQuery
		
	#region PatEstadoLiquidacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEstadoLiquidacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoLiquidacionFilters : PatEstadoLiquidacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionFilters class.
		/// </summary>
		public PatEstadoLiquidacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoLiquidacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoLiquidacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoLiquidacionFilters
	
	#region PatEstadoLiquidacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEstadoLiquidacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEstadoLiquidacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoLiquidacionQuery : PatEstadoLiquidacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionQuery class.
		/// </summary>
		public PatEstadoLiquidacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoLiquidacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoLiquidacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoLiquidacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoLiquidacionQuery
		
	#region PatEspecialidadMecanicoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEspecialidadMecanico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEspecialidadMecanicoFilters : PatEspecialidadMecanicoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoFilters class.
		/// </summary>
		public PatEspecialidadMecanicoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEspecialidadMecanicoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEspecialidadMecanicoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEspecialidadMecanicoFilters
	
	#region PatEspecialidadMecanicoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEspecialidadMecanicoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEspecialidadMecanico"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEspecialidadMecanicoQuery : PatEspecialidadMecanicoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoQuery class.
		/// </summary>
		public PatEspecialidadMecanicoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEspecialidadMecanicoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEspecialidadMecanicoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEspecialidadMecanicoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEspecialidadMecanicoQuery
		
	#region PatConfiguracionTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatConfiguracionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatConfiguracionTallerFilters : PatConfiguracionTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerFilters class.
		/// </summary>
		public PatConfiguracionTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatConfiguracionTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatConfiguracionTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatConfiguracionTallerFilters
	
	#region PatConfiguracionTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatConfiguracionTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatConfiguracionTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatConfiguracionTallerQuery : PatConfiguracionTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerQuery class.
		/// </summary>
		public PatConfiguracionTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatConfiguracionTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatConfiguracionTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatConfiguracionTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatConfiguracionTallerQuery
		
	#region PatEstadoCitaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEstadoCita"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoCitaFilters : PatEstadoCitaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaFilters class.
		/// </summary>
		public PatEstadoCitaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoCitaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoCitaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoCitaFilters
	
	#region PatEstadoCitaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEstadoCitaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEstadoCita"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoCitaQuery : PatEstadoCitaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaQuery class.
		/// </summary>
		public PatEstadoCitaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoCitaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoCitaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoCitaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoCitaQuery
		
	#region PatCargoOrdenFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCargoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCargoOrdenFilters : PatCargoOrdenFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenFilters class.
		/// </summary>
		public PatCargoOrdenFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCargoOrdenFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCargoOrdenFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCargoOrdenFilters
	
	#region PatCargoOrdenQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatCargoOrdenParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCargoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCargoOrdenQuery : PatCargoOrdenParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenQuery class.
		/// </summary>
		public PatCargoOrdenQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCargoOrdenQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCargoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCargoOrdenQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCargoOrdenQuery
		
	#region PatColorFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatColor"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatColorFilters : PatColorFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatColorFilters class.
		/// </summary>
		public PatColorFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatColorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatColorFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatColorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatColorFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatColorFilters
	
	#region PatColorQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatColorParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatColor"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatColorQuery : PatColorParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatColorQuery class.
		/// </summary>
		public PatColorQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatColorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatColorQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatColorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatColorQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatColorQuery
		
	#region PatCatalogoVehiculoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCatalogoVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCatalogoVehiculoFilters : PatCatalogoVehiculoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoFilters class.
		/// </summary>
		public PatCatalogoVehiculoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCatalogoVehiculoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCatalogoVehiculoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCatalogoVehiculoFilters
	
	#region PatCatalogoVehiculoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatCatalogoVehiculoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCatalogoVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCatalogoVehiculoQuery : PatCatalogoVehiculoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoQuery class.
		/// </summary>
		public PatCatalogoVehiculoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCatalogoVehiculoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCatalogoVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCatalogoVehiculoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCatalogoVehiculoQuery
		
	#region PatCapacidadTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCapacidadTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCapacidadTallerFilters : PatCapacidadTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerFilters class.
		/// </summary>
		public PatCapacidadTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCapacidadTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCapacidadTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCapacidadTallerFilters
	
	#region PatCapacidadTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatCapacidadTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCapacidadTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCapacidadTallerQuery : PatCapacidadTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerQuery class.
		/// </summary>
		public PatCapacidadTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCapacidadTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCapacidadTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCapacidadTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCapacidadTallerQuery
		
	#region PatCausalGarantiaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCausalGarantia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCausalGarantiaFilters : PatCausalGarantiaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaFilters class.
		/// </summary>
		public PatCausalGarantiaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCausalGarantiaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCausalGarantiaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCausalGarantiaFilters
	
	#region PatCausalGarantiaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatCausalGarantiaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCausalGarantia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCausalGarantiaQuery : PatCausalGarantiaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaQuery class.
		/// </summary>
		public PatCausalGarantiaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCausalGarantiaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCausalGarantiaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCausalGarantiaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCausalGarantiaQuery
		
	#region PatClienteFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCliente"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatClienteFilters : PatClienteFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatClienteFilters class.
		/// </summary>
		public PatClienteFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatClienteFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatClienteFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatClienteFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatClienteFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatClienteFilters
	
	#region PatClienteQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatClienteParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCliente"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatClienteQuery : PatClienteParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatClienteQuery class.
		/// </summary>
		public PatClienteQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatClienteQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatClienteQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatClienteQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatClienteQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatClienteQuery
		
	#region PatClaseVehiculoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatClaseVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatClaseVehiculoFilters : PatClaseVehiculoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoFilters class.
		/// </summary>
		public PatClaseVehiculoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatClaseVehiculoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatClaseVehiculoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatClaseVehiculoFilters
	
	#region PatClaseVehiculoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatClaseVehiculoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatClaseVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatClaseVehiculoQuery : PatClaseVehiculoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoQuery class.
		/// </summary>
		public PatClaseVehiculoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatClaseVehiculoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatClaseVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatClaseVehiculoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatClaseVehiculoQuery
		
	#region PatCitaTallerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatCitaTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCitaTallerFilters : PatCitaTallerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerFilters class.
		/// </summary>
		public PatCitaTallerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCitaTallerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCitaTallerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCitaTallerFilters
	
	#region PatCitaTallerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatCitaTallerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatCitaTaller"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatCitaTallerQuery : PatCitaTallerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerQuery class.
		/// </summary>
		public PatCitaTallerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatCitaTallerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatCitaTallerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatCitaTallerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatCitaTallerQuery
		
	#region PatEstadoOperacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEstadoOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoOperacionFilters : PatEstadoOperacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionFilters class.
		/// </summary>
		public PatEstadoOperacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoOperacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoOperacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoOperacionFilters
	
	#region PatEstadoOperacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEstadoOperacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEstadoOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoOperacionQuery : PatEstadoOperacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionQuery class.
		/// </summary>
		public PatEstadoOperacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoOperacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoOperacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoOperacionQuery
		
	#region PatItemListaPreciosFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemListaPrecios"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemListaPreciosFilters : PatItemListaPreciosFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosFilters class.
		/// </summary>
		public PatItemListaPreciosFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemListaPreciosFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemListaPreciosFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemListaPreciosFilters
	
	#region PatItemListaPreciosQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemListaPreciosParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemListaPrecios"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemListaPreciosQuery : PatItemListaPreciosParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosQuery class.
		/// </summary>
		public PatItemListaPreciosQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemListaPreciosQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemListaPreciosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemListaPreciosQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemListaPreciosQuery
		
	#region PatEstadoOrdenFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEstadoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoOrdenFilters : PatEstadoOrdenFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenFilters class.
		/// </summary>
		public PatEstadoOrdenFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoOrdenFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoOrdenFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoOrdenFilters
	
	#region PatEstadoOrdenQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEstadoOrdenParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEstadoOrden"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoOrdenQuery : PatEstadoOrdenParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenQuery class.
		/// </summary>
		public PatEstadoOrdenQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoOrdenQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoOrdenQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoOrdenQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoOrdenQuery
		
	#region PatItemOperacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemOperacionFilters : PatItemOperacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionFilters class.
		/// </summary>
		public PatItemOperacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemOperacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemOperacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemOperacionFilters
	
	#region PatItemOperacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemOperacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemOperacionQuery : PatItemOperacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionQuery class.
		/// </summary>
		public PatItemOperacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemOperacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemOperacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemOperacionQuery
		
	#region PatItemInventarioListaPreciosFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemInventarioListaPrecios"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemInventarioListaPreciosFilters : PatItemInventarioListaPreciosFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosFilters class.
		/// </summary>
		public PatItemInventarioListaPreciosFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemInventarioListaPreciosFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemInventarioListaPreciosFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemInventarioListaPreciosFilters
	
	#region PatItemInventarioListaPreciosQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemInventarioListaPreciosParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemInventarioListaPrecios"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemInventarioListaPreciosQuery : PatItemInventarioListaPreciosParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosQuery class.
		/// </summary>
		public PatItemInventarioListaPreciosQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemInventarioListaPreciosQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioListaPreciosQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemInventarioListaPreciosQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemInventarioListaPreciosQuery
		
	#region PatItemPeritajeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemPeritajeFilters : PatItemPeritajeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeFilters class.
		/// </summary>
		public PatItemPeritajeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemPeritajeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemPeritajeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemPeritajeFilters
	
	#region PatItemPeritajeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemPeritajeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemPeritajeQuery : PatItemPeritajeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeQuery class.
		/// </summary>
		public PatItemPeritajeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemPeritajeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemPeritajeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemPeritajeQuery
		
	#region PatMantenimientoProgramadoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatMantenimientoProgramado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMantenimientoProgramadoFilters : PatMantenimientoProgramadoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoFilters class.
		/// </summary>
		public PatMantenimientoProgramadoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMantenimientoProgramadoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMantenimientoProgramadoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMantenimientoProgramadoFilters
	
	#region PatMantenimientoProgramadoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatMantenimientoProgramadoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatMantenimientoProgramado"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatMantenimientoProgramadoQuery : PatMantenimientoProgramadoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoQuery class.
		/// </summary>
		public PatMantenimientoProgramadoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatMantenimientoProgramadoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatMantenimientoProgramadoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatMantenimientoProgramadoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatMantenimientoProgramadoQuery
		
	#region PatKitItemFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatKitItem"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitItemFilters : PatKitItemFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitItemFilters class.
		/// </summary>
		public PatKitItemFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitItemFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitItemFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitItemFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitItemFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitItemFilters
	
	#region PatKitItemQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatKitItemParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatKitItem"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitItemQuery : PatKitItemParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitItemQuery class.
		/// </summary>
		public PatKitItemQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitItemQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitItemQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitItemQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitItemQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitItemQuery
		
	#region PatItemInventarioFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemInventario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemInventarioFilters : PatItemInventarioFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioFilters class.
		/// </summary>
		public PatItemInventarioFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemInventarioFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemInventarioFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemInventarioFilters
	
	#region PatItemInventarioQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemInventarioParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemInventario"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemInventarioQuery : PatItemInventarioParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioQuery class.
		/// </summary>
		public PatItemInventarioQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemInventarioQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemInventarioQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemInventarioQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemInventarioQuery
		
	#region PatKitOperacionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatKitOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitOperacionFilters : PatKitOperacionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionFilters class.
		/// </summary>
		public PatKitOperacionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitOperacionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitOperacionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitOperacionFilters
	
	#region PatKitOperacionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatKitOperacionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatKitOperacion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatKitOperacionQuery : PatKitOperacionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionQuery class.
		/// </summary>
		public PatKitOperacionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatKitOperacionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatKitOperacionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatKitOperacionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatKitOperacionQuery
		
	#region PatHistoricEntityFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatHistoricEntity"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricEntityFilters : PatHistoricEntityFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityFilters class.
		/// </summary>
		public PatHistoricEntityFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricEntityFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricEntityFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricEntityFilters
	
	#region PatHistoricEntityQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatHistoricEntityParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatHistoricEntity"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricEntityQuery : PatHistoricEntityParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityQuery class.
		/// </summary>
		public PatHistoricEntityQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricEntityQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricEntityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricEntityQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricEntityQuery
		
	#region PatItemGrupoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemGrupo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemGrupoFilters : PatItemGrupoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoFilters class.
		/// </summary>
		public PatItemGrupoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemGrupoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemGrupoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemGrupoFilters
	
	#region PatItemGrupoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemGrupoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemGrupo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemGrupoQuery : PatItemGrupoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoQuery class.
		/// </summary>
		public PatItemGrupoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemGrupoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemGrupoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemGrupoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemGrupoQuery
		
	#region PatEstadoPeritajeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatEstadoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoPeritajeFilters : PatEstadoPeritajeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeFilters class.
		/// </summary>
		public PatEstadoPeritajeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoPeritajeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoPeritajeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoPeritajeFilters
	
	#region PatEstadoPeritajeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatEstadoPeritajeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatEstadoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatEstadoPeritajeQuery : PatEstadoPeritajeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeQuery class.
		/// </summary>
		public PatEstadoPeritajeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatEstadoPeritajeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatEstadoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatEstadoPeritajeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatEstadoPeritajeQuery
		
	#region PatHistoricAttributeByEntityFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatHistoricAttributeByEntity"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricAttributeByEntityFilters : PatHistoricAttributeByEntityFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityFilters class.
		/// </summary>
		public PatHistoricAttributeByEntityFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricAttributeByEntityFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricAttributeByEntityFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricAttributeByEntityFilters
	
	#region PatHistoricAttributeByEntityQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatHistoricAttributeByEntityParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatHistoricAttributeByEntity"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricAttributeByEntityQuery : PatHistoricAttributeByEntityParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityQuery class.
		/// </summary>
		public PatHistoricAttributeByEntityQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricAttributeByEntityQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricAttributeByEntityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricAttributeByEntityQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricAttributeByEntityQuery
		
	#region PatGamaVehiculoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatGamaVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGamaVehiculoFilters : PatGamaVehiculoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoFilters class.
		/// </summary>
		public PatGamaVehiculoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGamaVehiculoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGamaVehiculoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGamaVehiculoFilters
	
	#region PatGamaVehiculoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatGamaVehiculoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatGamaVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGamaVehiculoQuery : PatGamaVehiculoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoQuery class.
		/// </summary>
		public PatGamaVehiculoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGamaVehiculoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGamaVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGamaVehiculoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGamaVehiculoQuery
		
	#region PatGrupoPeritajeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatGrupoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGrupoPeritajeFilters : PatGrupoPeritajeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeFilters class.
		/// </summary>
		public PatGrupoPeritajeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGrupoPeritajeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGrupoPeritajeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGrupoPeritajeFilters
	
	#region PatGrupoPeritajeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatGrupoPeritajeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatGrupoPeritaje"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatGrupoPeritajeQuery : PatGrupoPeritajeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeQuery class.
		/// </summary>
		public PatGrupoPeritajeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatGrupoPeritajeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatGrupoPeritajeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatGrupoPeritajeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatGrupoPeritajeQuery
		
	#region PatHistoricFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatHistoric"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricFilters : PatHistoricFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricFilters class.
		/// </summary>
		public PatHistoricFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricFilters
	
	#region PatHistoricQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatHistoricParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatHistoric"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatHistoricQuery : PatHistoricParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatHistoricQuery class.
		/// </summary>
		public PatHistoricQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatHistoricQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatHistoricQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatHistoricQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatHistoricQuery
		
	#region PatItemCatalogoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatItemCatalogo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemCatalogoFilters : PatItemCatalogoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoFilters class.
		/// </summary>
		public PatItemCatalogoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemCatalogoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemCatalogoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemCatalogoFilters
	
	#region PatItemCatalogoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatItemCatalogoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatItemCatalogo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatItemCatalogoQuery : PatItemCatalogoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoQuery class.
		/// </summary>
		public PatItemCatalogoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatItemCatalogoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatItemCatalogoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatItemCatalogoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatItemCatalogoQuery
		
	#region PatVehiculoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PatVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatVehiculoFilters : PatVehiculoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatVehiculoFilters class.
		/// </summary>
		public PatVehiculoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatVehiculoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatVehiculoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatVehiculoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatVehiculoFilters
	
	#region PatVehiculoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PatVehiculoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PatVehiculo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PatVehiculoQuery : PatVehiculoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PatVehiculoQuery class.
		/// </summary>
		public PatVehiculoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PatVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PatVehiculoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PatVehiculoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PatVehiculoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PatVehiculoQuery
	#endregion

	
}
